package com.iaz.tech.tools.tasks.pool;
/**
 *  Copyright: 自由开发
 *  author: 赵黎民
 *  description： ExecuteTaskForPool 是多任务池的线程，持续等待
 *                   
 */
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.iaz.tech.tools.tasks.ability.ITaskPoolExecutorAble;
import com.iaz.tech.tools.property.IPropertyAble;
import com.iaz.tech.tools.tasks.ability.IScheduleAble; 
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.iaz.tech.tools.common.utils.DoublyLinkedList;

/**
 * @apiNote 持续运行
 * 在执行池中，始终运行的线程
 *
 */
@EqualsAndHashCode(callSuper = true)
@Data
public class ExecuteTaskForPool extends Thread implements ITaskPoolExecutorAble {
	/**
     * 日志
     */
	private final static Logger logger = (Logger) LoggerFactory.getLogger(ExecuteTaskForPool.class);

    private boolean running = true;
	/* 内部的TaskItem */
	//private ITaskItemAble task = null;
	/**
	 * 执行计划
	 * 新版任务，代替ITaskItemAble, 用计划来进行处理
	 * 将一个任务，可以拆成多个计划，进行处理。
	 * 执行一个步骤后，先释放， 等待下次载入的时候
	 * 在执行下一个步骤。用于提供任务的并行执行的广度。优化计算资源，并
	 * 设计跟踪点，可以根据上一步执行情况，确定是否执行下一个步骤。
	 * 满足神经元的并发调用。
	 * 在执行的过程中，进行处理
	 * 
	 * 主要根据Plan 来确定计划
	 *
	 */
	private IScheduleAble taskList = null;
	/**
	 * 线程池
	 */
	private ZTecThreadsPool pool = null;

	/* 接收执行任务的ITEM 的开始时间， 用于判断任务执行是否超时，一次任务执行时间，会比较慢*/
	private long timeForItemInvoked = 0L;

	private static long _SERIALNO = 0L;
	/* 同步 */
	private static final String _SERIAL_SYN_TILE = "__SERIAL_NO";
	
	public static  String generateCode(){
		synchronized( _SERIAL_SYN_TILE ){
			if( _SERIALNO > 99999999){
				_SERIALNO = 0L;
			}
			_SERIALNO++;
		}
		return "TASK_ZFR_" + _SERIALNO;
	}
	
	public void setTaskName(String _name ){ 
		super.setName(_name);
	}

	/**
	 * 本任务可以执行多个计划
	 * 将最新的计划加入到队列中
	 */
    @Override
	public void registerTask(IScheduleAble ITaskItemAble) {
		try {
			/* 将当前ScheduleAble 加入到任务队列 */
			this.taskList = ITaskItemAble;

		} catch (Exception exception){
			logger.error("注册任务异常：" + exception.getMessage() ); 		
		}
    }
    
    /**
	 * 获得任务
	 * @return
	 */
	public IScheduleAble forTask() {
		try {
			return this.taskList;
		} catch(Exception exception){
			logger.error("获得任务异常：" + exception.getMessage() ); 		
		} 
		return null;
	}

    /**
     * 替换Thread , 可以持续运行
     */
    @Override
	public void run() {
		while( running ) {
			try {
				Map<String,Object> properties = new HashMap<String, Object>();				
				this.invoke(properties);				
			}catch(Exception e) {
				logger.error("执行run 异常：" + e.getMessage() ); 			
			}finally {
				try {
					Thread.sleep(100);
				}catch(Exception exs) {
					logger.error("执行 Thread.sleep(100) 异常：" + exs.getMessage() ); 		
				}
			}
		}
    }
    
	/**
	 * 调度
	 * @param sender
	 */
	public void invoke(Object sender) {
		if( this.isFree()) return;
		if( this.taskList != null ) {			
			try {
				/* 从头开始弹出计划 */
				IScheduleAble task = this.forTask();
				if( task == null ){
					throw new NullPointerException("任务为空");
				}
				/* 匹配当前是否可以执行计划 */
				task.execute(sender);
			}catch(Exception e) {
				logger.error("执行 invoke(Object sender)  异常：" + e.getMessage() ); 	 
			}finally {
				
			}	
		}
	}

	/**
	 * 判断是否有空闲
	 * @return  true: 为空闲  false : 为繁忙
	 */
	@Override
	public boolean isFree() {
		return this.taskList == null;
	}

	@Override
	public void free() {
		if( this.taskList != null ){
			synchronized( this.taskList ){
				this.taskList.stop();        
			}				
		}
		this.taskList = null;		
	}

	@Override
	public void stopTask() {
		synchronized(this) {
			this.running = false;
		}
	}
	
}
